مکانیسم‌های تلاش مجدد پایتون: ایجاد سیستم‌های مقاوم برای مخاطبان جهانی

در محیط‌های محاسباتی توزیع‌شده و اغلب غیرقابل پیش‌بینی امروزی، ایجاد سیستم‌های مقاوم و دارای تحمل خطا بسیار مهم است. برنامه‌ها، به ویژه آنهایی که به مخاطبان جهانی خدمات ارائه می‌دهند، باید بتوانند با ظرافت از پس خرابی‌های گذرا مانند اشکالات شبکه، عدم دسترسی موقت به سرویس یا رقابت منابع برآیند. پایتون، با اکوسیستم غنی خود، چندین ابزار قدرتمند برای پیاده‌سازی مکانیسم‌های تلاش مجدد ارائه می‌دهد و برنامه‌ها را قادر می‌سازد تا به طور خودکار از این خطاهای گذرا بهبود یابند و عملکرد مداوم را حفظ کنند.

چرا مکانیسم‌های تلاش مجدد برای برنامه‌های جهانی حیاتی هستند

برنامه‌های جهانی با چالش‌های منحصربه‌فردی روبرو هستند که بر اهمیت مکانیسم‌های تلاش مجدد تأکید می‌کنند:

• ناپایداری شبکه: اتصال به اینترنت در مناطق مختلف تفاوت چشمگیری دارد. برنامه‌هایی که به کاربران در مناطقی با زیرساخت کمتر قابل اعتماد خدمات ارائه می‌دهند، بیشتر با اختلالات شبکه مواجه می‌شوند.
• معماری‌های توزیع‌شده: برنامه‌های مدرن اغلب به میکروسرویس‌ها و سیستم‌های توزیع‌شده متکی هستند، که احتمال خرابی‌های ارتباطی بین سرویس‌ها را افزایش می‌دهد.
• اضافه بار سرویس: افزایش ناگهانی ترافیک کاربر، به ویژه در ساعات اوج مصرف در مناطق زمانی مختلف، می‌تواند سرویس‌ها را تحت فشار قرار دهد و منجر به عدم دسترسی موقت شود.
• وابستگی‌های خارجی: برنامه‌ها اغلب به APIها یا سرویس‌های شخص ثالث وابسته هستند، که ممکن است گاهی اوقات دچار خرابی یا مشکلات عملکرد شوند.
• خطاهای اتصال به پایگاه داده: خرابی‌های متناوب اتصال به پایگاه داده رایج است، به ویژه تحت بار سنگین.

بدون مکانیسم‌های تلاش مجدد مناسب، این خرابی‌های گذرا می‌تواند منجر به خرابی برنامه، از دست رفتن داده‌ها و تجربه کاربری ضعیف شود. پیاده‌سازی منطق تلاش مجدد به برنامه شما اجازه می‌دهد تا به طور خودکار برای بازیابی از این خطاها تلاش کند و قابلیت اطمینان و دسترسی کلی آن را بهبود بخشد.

درک استراتژی‌های تلاش مجدد

قبل از پرداختن به پیاده‌سازی پایتون، مهم است که استراتژی‌های تلاش مجدد رایج را درک کنید:

• تلاش مجدد ساده: ساده‌ترین استراتژی شامل تلاش مجدد برای عملیات به تعداد دفعات ثابت با تأخیر ثابت بین هر تلاش است.
• بازگشت نمایی: این استراتژی تأخیر بین تلاش‌های مجدد را به طور نمایی افزایش می‌دهد. این برای جلوگیری از تحت فشار قرار دادن سرویس ناموفق با درخواست‌های مکرر بسیار مهم است. به عنوان مثال، تأخیر می‌تواند 1 ثانیه، سپس 2 ثانیه، سپس 4 ثانیه و غیره باشد.
• لرزش: افزودن مقدار کمی تغییرات تصادفی (لرزش) به تأخیر به جلوگیری از تلاش مجدد همزمان چندین مشتری و بارگیری بیشتر سرویس کمک می‌کند.
• قطع کننده مدار: این الگو از تلاش مکرر یک برنامه برای عملیاتی که احتمالاً با شکست مواجه می‌شود، جلوگیری می‌کند. پس از تعداد مشخصی از شکست‌ها، قطع کننده مدار "باز" می‌شود و از تلاش‌های بیشتر برای یک دوره مشخص جلوگیری می‌کند. پس از اتمام زمان، قطع کننده مدار وارد حالت "نیمه باز" می‌شود و به تعداد محدودی از درخواست‌ها اجازه می‌دهد تا از طریق آن عبور کنند تا آزمایش کنند که آیا سرویس بازیابی شده است یا خیر. اگر درخواست‌ها موفقیت‌آمیز باشند، قطع کننده مدار "بسته" می‌شود و عملکرد عادی را از سر می‌گیرد.
• تلاش مجدد با مهلت زمانی: یک محدودیت زمانی تعیین می‌شود. تلاش‌های مجدد تا رسیدن به مهلت زمانی انجام می‌شود، حتی اگر حداکثر تعداد تلاش‌های مجدد تمام نشده باشد.

پیاده‌سازی مکانیسم‌های تلاش مجدد در پایتون با استفاده از `tenacity`

کتابخانه `tenacity` یک کتابخانه پایتون محبوب و قدرتمند برای افزودن منطق تلاش مجدد به کد شما است. این یک روش انعطاف‌پذیر و قابل تنظیم برای رسیدگی به خطاهای گذرا ارائه می‌دهد.

نصب

نصب `tenacity` با استفاده از pip:

            pip install tenacity
            

              
                Copy
              
            
          

مثال اولیه تلاش مجدد

در اینجا یک مثال ساده از استفاده از `tenacity` برای تلاش مجدد برای تابعی که ممکن است با شکست مواجه شود آورده شده است:

            from tenacity import retry, stop_after_attempt

@retry(stop=stop_after_attempt(3))
def unreliable_function():
 print("Attempting to connect to the database...")
 # Simulate a potential database connection error
 import random
 if random.random() < 0.5:
 raise IOError("Failed to connect to the database")
 else:
 print("Successfully connected to the database!")
 return "Database connection successful"

try:
 result = unreliable_function()
 print(result)
except IOError as e:
 print(f"Failed to connect after multiple retries: {e}")

            

              
                Copy
              
            
          

در این مثال:

• `@retry(stop=stop_after_attempt(3))` یک دکوراتور است که منطق تلاش مجدد را روی `unreliable_function` اعمال می‌کند.
• `stop_after_attempt(3)` مشخص می‌کند که تابع باید حداکثر 3 بار مجدداً امتحان شود.
• `unreliable_function` یک اتصال پایگاه داده را شبیه‌سازی می‌کند که ممکن است به طور تصادفی با شکست مواجه شود.
• بلوک `try...except` `IOError` را مدیریت می‌کند که ممکن است در صورت شکست تابع پس از اتمام تمام تلاش‌های مجدد ایجاد شود.

استفاده از بازگشت نمایی و لرزش

برای پیاده‌سازی بازگشت نمایی و لرزش، می‌توانید از استراتژی‌های `wait` ارائه شده توسط `tenacity` استفاده کنید:

            from tenacity import retry, stop_after_attempt, wait_exponential, wait_random

@retry(stop=stop_after_attempt(5), wait=wait_exponential(multiplier=1, min=1, max=10) + wait_random(0, 1))
def unreliable_function_with_backoff():
 print("Attempting to connect to the API...")
 # Simulate a potential API error
 import random
 if random.random() < 0.7:
 raise Exception("API request failed")
 else:
 print("API request successful!")
 return "API request successful"

try:
 result = unreliable_function_with_backoff()
 print(result)
except Exception as e:
 print(f"API request failed after multiple retries: {e}")

            

              
                Copy
              
            
          

در این مثال:

• `wait_exponential(multiplier=1, min=1, max=10)` بازگشت نمایی را پیاده‌سازی می‌کند. تأخیر از 1 ثانیه شروع می‌شود و به طور نمایی افزایش می‌یابد، تا حداکثر 10 ثانیه.
• `wait_random(0, 1)` یک لرزش تصادفی بین 0 و 1 ثانیه به تأخیر اضافه می‌کند.

مدیریت استثنائات خاص

همچنین می‌توانید `tenacity` را پیکربندی کنید تا فقط در مورد استثنائات خاص دوباره امتحان کند:

            from tenacity import retry, stop_after_attempt, retry_if_exception_type

@retry(stop=stop_after_attempt(3), retry=retry_if_exception_type(ConnectionError))
def unreliable_network_operation():
 print("Attempting network operation...")
 # Simulate a potential network connection error
 import random
 if random.random() < 0.3:
 raise ConnectionError("Network connection failed")
 else:
 print("Network operation successful!")
 return "Network operation successful"

try:
 result = unreliable_network_operation()
 print(result)
except ConnectionError as e:
 print(f"Network operation failed after multiple retries: {e}")
except Exception as e:
 print(f"An unexpected error occurred: {e}")

            

              
                Copy
              
            
          

در این مثال:

• `retry_if_exception_type(ConnectionError)` مشخص می‌کند که تابع فقط در صورت ایجاد `ConnectionError` باید مجدداً امتحان شود. استثنائات دیگر مجدداً امتحان نخواهند شد.

استفاده از قطع کننده مدار

در حالی که `tenacity` مستقیماً پیاده‌سازی قطع کننده مدار را ارائه نمی‌دهد، می‌توانید آن را با یک کتابخانه قطع کننده مدار جداگانه ادغام کنید یا منطق سفارشی خود را پیاده‌سازی کنید. در اینجا یک مثال ساده از نحوه پیاده‌سازی یک قطع کننده مدار اساسی آورده شده است:

            import time
from tenacity import retry, stop_after_attempt, retry_if_exception_type

class CircuitBreaker:
 def __init__(self, failure_threshold, reset_timeout):
 self.failure_threshold = failure_threshold
 self.reset_timeout = reset_timeout
 self.failure_count = 0
 self.last_failure_time = None
 self.state = "CLOSED"

 def call(self, func, *args, **kwargs):
 if self.state == "OPEN":
 if time.time() - self.last_failure_time > self.reset_timeout:
 self.state = "HALF_OPEN"
 else:
 raise Exception("Circuit breaker is open")

 try:
 result = func(*args, **kwargs)
 self.reset()
 return result
 except Exception as e:
 self.record_failure()
 raise e

 def record_failure(self):
 self.failure_count += 1
 self.last_failure_time = time.time()
 if self.failure_count >= self.failure_threshold:
 self.open()

 def open(self):
 self.state = "OPEN"
 print("Circuit breaker opened")

 def reset(self):
 self.failure_count = 0
 self.state = "CLOSED"
 print("Circuit breaker closed")

def unreliable_service():
 import random
 if random.random() < 0.8:
 raise Exception("Service unavailable")
 else:
 return "Service is available"

# Example Usage
circuit_breaker = CircuitBreaker(failure_threshold=3, reset_timeout=10)

for _ in range(10):
 try:
 result = circuit_breaker.call(unreliable_service)
 print(f"Service result: {result}")
 except Exception as e:
 print(f"Error: {e}")
 time.sleep(1)

            

              
                Copy
              
            
          

این مثال یک قطع کننده مدار اساسی را نشان می‌دهد که:

• تعداد شکست‌ها را ردیابی می‌کند.
• پس از تعداد مشخصی از شکست‌ها، قطع کننده مدار را باز می‌کند.
• پس از اتمام زمان، به تعداد محدودی از درخواست‌ها اجازه می‌دهد تا در حالت "نیمه باز" از طریق آن عبور کنند.
• اگر درخواست‌ها در حالت "نیمه باز" موفقیت‌آمیز باشند، قطع کننده مدار را می‌بندد.

نکته مهم: این یک مثال ساده است. پیاده‌سازی‌های قطع کننده مدار آماده تولید پیچیده‌تر هستند و ممکن است شامل ویژگی‌هایی مانند زمان‌های انتظار قابل تنظیم، ردیابی معیارها و ادغام با سیستم‌های نظارت باشند.

ملاحظات جهانی برای مکانیسم‌های تلاش مجدد

هنگام پیاده‌سازی مکانیسم‌های تلاش مجدد برای برنامه‌های جهانی، موارد زیر را در نظر بگیرید:

• زمان‌های انتظار: زمان‌های انتظار مناسب را برای تلاش‌های مجدد و قطع کننده‌های مدار پیکربندی کنید، و تأخیر شبکه را در مناطق مختلف در نظر بگیرید. یک زمان انتظار که در آمریکای شمالی کافی است ممکن است برای اتصالات به آسیای جنوب شرقی کافی نباشد.
• آی‌دمپوتنسی: اطمینان حاصل کنید که عملیاتی که مجدداً امتحان می‌شوند، آی‌دمپوتنت هستند، به این معنی که می‌توانند چندین بار بدون ایجاد عوارض جانبی ناخواسته اجرا شوند. به عنوان مثال، از افزایش شمارنده باید در عملیات آی‌دمپوتنت اجتناب شود. اگر یک عملیات آی‌دمپوتنت *نیست*، باید اطمینان حاصل کنید که مکانیسم تلاش مجدد عملیات را *دقیقاً* یک بار اجرا می‌کند، یا معاملات جبرانی را برای تصحیح اجرای چندگانه پیاده‌سازی می‌کند.
• ثبت و نظارت: ثبت و نظارت جامع را برای ردیابی تلاش‌های مجدد، شکست‌ها و وضعیت قطع کننده مدار پیاده‌سازی کنید. این به شما کمک می‌کند تا مسائل را شناسایی و تشخیص دهید.
• تجربه کاربری: از تلاش مجدد برای عملیات به طور نامحدود خودداری کنید، زیرا این می‌تواند منجر به تجربه کاربری ضعیف شود. پیام‌های خطای آموزنده را به کاربر ارائه دهید و به آنها اجازه دهید در صورت لزوم به صورت دستی دوباره امتحان کنند.
• مناطق در دسترس منطقه‌ای: اگر از خدمات ابری استفاده می‌کنید، برنامه خود را در چندین منطقه در دسترس مستقر کنید تا انعطاف‌پذیری را بهبود ببخشید. منطق تلاش مجدد را می‌توان به گونه‌ای پیکربندی کرد که در صورت عدم دسترسی یکی، به یک منطقه در دسترس دیگر منتقل شود.
• حساسیت فرهنگی: هنگام نمایش پیام‌های خطا به کاربران، مراقب تفاوت‌های فرهنگی باشید و از استفاده از زبانی که ممکن است توهین‌آمیز یا بی‌احساس باشد، خودداری کنید.
• محدود کردن نرخ: محدود کردن نرخ را پیاده‌سازی کنید تا از تحت فشار قرار دادن سرویس‌های وابسته با درخواست‌های تلاش مجدد توسط برنامه خود جلوگیری کنید. این امر به ویژه هنگام تعامل با APIهای شخص ثالث مهم است. استفاده از استراتژی‌های محدود کردن نرخ تطبیقی ​​را در نظر بگیرید که نرخ را بر اساس بار فعلی سرویس تنظیم می‌کنند.
• سازگاری داده: هنگام تلاش مجدد برای عملیات پایگاه داده، اطمینان حاصل کنید که سازگاری داده حفظ می‌شود. از تراکنش‌ها و سایر مکانیسم‌ها برای جلوگیری از خراب شدن داده‌ها استفاده کنید.

مثال: تلاش مجدد برای تماس‌های API به یک درگاه پرداخت جهانی

فرض کنید شما در حال ساخت یک پلتفرم تجارت الکترونیک هستید که پرداخت‌ها را از مشتریان در سراسر جهان می‌پذیرد. شما برای پردازش تراکنش‌ها به API یک درگاه پرداخت شخص ثالث متکی هستید. این API ممکن است گاهی اوقات دچار خرابی یا مشکلات عملکرد شود.

در اینجا نحوه استفاده از `tenacity` برای تلاش مجدد برای تماس‌های API به درگاه پرداخت آورده شده است:

            import requests
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type

class PaymentGatewayError(Exception):
 pass

@retry(stop=stop_after_attempt(5),
 wait=wait_exponential(multiplier=1, min=1, max=30),
 retry=retry_if_exception_type((requests.exceptions.RequestException, PaymentGatewayError)))
def process_payment(payment_data):
 try:
 # Replace with your actual payment gateway API endpoint
 api_endpoint = "https://api.example-payment-gateway.com/process_payment"

 # Make the API request
 response = requests.post(api_endpoint, json=payment_data, timeout=10)
 response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)

 # Parse the response
 data = response.json()

 # Check for errors in the response
 if data.get("status") != "success":
 raise PaymentGatewayError(data.get("message", "Payment processing failed"))

 return data

 except requests.exceptions.RequestException as e:
 print(f"Request Exception: {e}")
 raise # Re-raise the exception to trigger retry
 except PaymentGatewayError as e:
 print(f"Payment Gateway Error: {e}")
 raise # Re-raise the exception to trigger retry

# Example usage
payment_data = {
 "amount": 100.00,
 "currency": "USD",
 "card_number": "...",
 "expiry_date": "...",
 "cvv": "..."
}

try:
 result = process_payment(payment_data)
 print(f"Payment processed successfully: {result}")
except Exception as e:
 print(f"Payment processing failed after multiple retries: {e}")

            

              
                Copy
              
            
          

در این مثال:

• ما یک استثنای `PaymentGatewayError` سفارشی را برای مدیریت خطاهای خاص API درگاه پرداخت تعریف می‌کنیم.
• ما از `retry_if_exception_type` استفاده می‌کنیم تا فقط در مورد `requests.exceptions.RequestException` (برای خطاهای شبکه) و `PaymentGatewayError` دوباره امتحان کنیم.
• ما یک زمان انتظار 10 ثانیه برای درخواست API تعیین می‌کنیم تا از معلق شدن نامحدود آن جلوگیری کنیم.
• ما از `response.raise_for_status()` استفاده می‌کنیم تا یک HTTPError را برای پاسخ‌های بد (4xx یا 5xx) افزایش دهیم.
• ما وضعیت پاسخ را بررسی می‌کنیم و در صورت عدم موفقیت در پردازش پرداخت، یک `PaymentGatewayError` را افزایش می‌دهیم.
• ما از بازگشت نمایی با حداقل تأخیر 1 ثانیه و حداکثر تأخیر 30 ثانیه استفاده می‌کنیم.

این مثال نشان می‌دهد که چگونه از `tenacity` برای ساخت یک سیستم پردازش پرداخت قوی و دارای تحمل خطا استفاده کنید که می‌تواند خطاهای گذرا API را مدیریت کند و اطمینان حاصل کند که پرداخت‌ها به طور قابل اعتماد پردازش می‌شوند.

جایگزین‌هایی برای `tenacity`

در حالی که `tenacity` یک انتخاب محبوب است، کتابخانه‌ها و رویکردهای دیگر می‌توانند به نتایج مشابهی دست یابند:

• کتابخانه `retrying`: یکی دیگر از کتابخانه‌های پایتون با سابقه طولانی برای تلاش مجدد، که عملکردی قابل مقایسه با `tenacity` ارائه می‌دهد.
• `aiohttp-retry` (برای کد ناهمزمان): اگر با کد ناهمزمان (`asyncio`) کار می‌کنید، `aiohttp-retry` قابلیت‌های تلاش مجدد را به طور خاص برای مشتریان `aiohttp` ارائه می‌دهد.
• منطق تلاش مجدد سفارشی: برای سناریوهای ساده‌تر، می‌توانید منطق تلاش مجدد خود را با استفاده از بلوک‌های `try...except` و `time.sleep()` پیاده‌سازی کنید. با این حال، استفاده از یک کتابخانه اختصاصی مانند `tenacity` به طور کلی برای سناریوهای پیچیده‌تر توصیه می‌شود، زیرا انعطاف‌پذیری و قابلیت پیکربندی بیشتری را ارائه می‌دهد.
• مش‌های سرویس (به عنوان مثال، Istio، Linkerd): مش‌های سرویس اغلب قابلیت‌های داخلی تلاش مجدد و قطع کننده مدار را ارائه می‌دهند، که می‌توانند در سطح زیرساخت بدون تغییر کد برنامه شما پیکربندی شوند.

نتیجه‌گیری

پیاده‌سازی مکانیسم‌های تلاش مجدد برای ساخت سیستم‌های مقاوم و دارای تحمل خطا، به ویژه برای برنامه‌های جهانی که نیاز به رسیدگی به پیچیدگی‌های محیط‌های توزیع‌شده دارند، ضروری است. پایتون، با کتابخانه‌هایی مانند `tenacity`، ابزارهایی را برای اضافه کردن آسان منطق تلاش مجدد به کد شما فراهم می‌کند و قابلیت اطمینان و دسترسی برنامه‌های شما را بهبود می‌بخشد. با درک استراتژی‌های مختلف تلاش مجدد و در نظر گرفتن عوامل جهانی مانند تأخیر شبکه و حساسیت فرهنگی، می‌توانید برنامه‌هایی بسازید که یک تجربه کاربری یکپارچه و قابل اعتماد را برای مشتریان در سراسر جهان ارائه می‌دهند.

به یاد داشته باشید که نیازهای خاص برنامه خود را به دقت در نظر بگیرید و استراتژی و پیکربندی تکرار را انتخاب کنید که به بهترین وجه با نیازهای شما مطابقت دارد. ثبت، نظارت و آزمایش مناسب نیز برای اطمینان از اینکه مکانیسم‌های تلاش مجدد شما به طور موثر کار می‌کنند و برنامه شما تحت شرایط مختلف خرابی مطابق انتظار رفتار می‌کند، بسیار مهم است.